home *** CD-ROM | disk | FTP | other *** search
/ Windows Game Programming for Dummies (2nd Edition) / WinGamProgFD.iso / pc / DirectX SDK / DXSDK / samples / Multimedia / Demos / DMBoids / music.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-10-31  |  28.4 KB  |  1,116 lines
  1. //-----------------------------------------------------------------------------
  2. // File: Music.cpp
  3. //
  4. // Desc: 
  5. //       
  6. // Copyright (c) 1995-2001 Microsoft Corporation. All rights reserved.
  7. //-----------------------------------------------------------------------------
  8. #define STRICT
  9. #include <windows.h>
  10. #include <tchar.h>
  11. #include <oleauto.h>
  12. #include <stdio.h>
  13. #include "DXUtil.h"
  14. #include "music.h"
  15.  
  16.  
  17.  
  18.  
  19.  
  20. //-----------------------------------------------------------------------------
  21. // Name: 
  22. // Desc: 
  23. //-----------------------------------------------------------------------------
  24. BoidMusic::BoidMusic()
  25. {
  26.     m_dwBeatsSinceLastMotif = 0;
  27.     m_pSegment = NULL;
  28.     m_pPort = NULL;
  29.     m_pDMusic = NULL;
  30.     m_fCollapsed = FALSE;
  31.     m_dwIndex = 0;
  32.     m_pBand = NULL;
  33.     m_pStyle = NULL;
  34.     m_pChordMap = NULL;
  35.     long x;
  36.     for (x = 0; x < 6; x++)
  37.     {
  38.         m_pTemplateSegments[x] = NULL;
  39.         m_pPrimarySegments[x] = NULL;
  40.         m_pMotifSegments[x] = NULL;
  41.     }
  42.     m_pPrimarySegments[1] = NULL;
  43.     m_pTransitionSegment = NULL;
  44.     m_pComposer = NULL;
  45.     m_pLoader = NULL;
  46.     m_pPerformance = NULL;
  47. }
  48.  
  49.  
  50.  
  51.  
  52. //-----------------------------------------------------------------------------
  53. // Name: 
  54. // Desc: 
  55. //-----------------------------------------------------------------------------
  56. BoidMusic::~BoidMusic()
  57. {
  58.     long x;
  59.     if (m_pSegment)
  60.     {
  61.         m_pSegment->Release();
  62.     }
  63.     if (m_pBand)
  64.     {
  65.         if(m_pPerformance)
  66.         {
  67.             m_pBand->Unload(m_pPerformance);
  68.         }
  69.         m_pBand->Release();
  70.     }
  71.     if (m_pGraph)
  72.     {
  73.         m_pGraph->Release();
  74.     }
  75.     if (m_pPort)
  76.     {
  77.         m_pPort->Release();
  78.     }
  79.     if (m_pDMusic)
  80.     {
  81.         m_pDMusic->Release();
  82.     }
  83.     for (x = 0; x< 6; x++)
  84.     {
  85.         if (m_pTemplateSegments[x])
  86.         {
  87.             m_pTemplateSegments[x]->Release();
  88.         }
  89.         if (m_pPrimarySegments[x])
  90.         {
  91.             m_pPrimarySegments[x]->Release();
  92.         }
  93.         if (m_pMotifSegments[x])
  94.         {
  95.             m_pMotifSegments[x]->Release();
  96.         }
  97.     }
  98.     if (m_pStyle)
  99.     {
  100.         m_pStyle->Release();
  101.     }
  102.     if (m_pChordMap)
  103.     {
  104.         m_pChordMap->Release();
  105.     }
  106.     if (m_pTransitionSegment)
  107.     {
  108.         m_pTransitionSegment->Release();
  109.     }
  110.     if (m_pComposer)
  111.     {
  112.         m_pComposer->Release();
  113.     }
  114.     if (m_pLoader)
  115.     {
  116.         m_pLoader->Release();
  117.     }
  118.     if (m_pPerformance)
  119.     {
  120.         m_pPerformance->Release();
  121.     }
  122.     if( m_hNotify )
  123.     {
  124.         CloseHandle( m_hNotify );
  125.     }
  126. }
  127.  
  128.  
  129.  
  130.  
  131. //-----------------------------------------------------------------------------
  132. // Name: 
  133. // Desc: 
  134. //-----------------------------------------------------------------------------
  135. BOOL BoidMusic::LoadStyle()
  136. {
  137.     if (m_pStyle) m_pStyle->Release();
  138.  
  139.     DMUS_OBJECTDESC ObjectDescript;
  140.     ObjectDescript.guidClass = CLSID_DirectMusicStyle;
  141.     wcscpy(ObjectDescript.wszFileName, L"Boids2.sty");
  142.     ObjectDescript.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME ;
  143.     ObjectDescript.dwSize = sizeof(DMUS_OBJECTDESC);
  144.     if (SUCCEEDED(m_pLoader->GetObject(&ObjectDescript, IID_IDirectMusicStyle, (void**)&m_pStyle)))
  145.     {
  146.         BSTR bstr = SysAllocString(L"Default");
  147.         m_pStyle->GetBand(bstr, &m_pBand) ;
  148.         SysFreeString(bstr);
  149.  
  150.         return TRUE;
  151.     }
  152.  
  153.     return FALSE;
  154. }
  155.  
  156.  
  157.  
  158.  
  159. //-----------------------------------------------------------------------------
  160. // Name: 
  161. // Desc: This loads a precomposed segment.
  162. //-----------------------------------------------------------------------------
  163. BOOL BoidMusic::LoadSegment()
  164. {
  165.     if (m_pSegment) m_pSegment->Release();
  166.  
  167.     DMUS_OBJECTDESC ObjectDescript;
  168.     ObjectDescript.guidClass = CLSID_DirectMusicSegment;
  169.     wcscpy(ObjectDescript.wszFileName, L"BoidsD.sgt");
  170.     ObjectDescript.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME ;
  171.     ObjectDescript.dwSize = sizeof(DMUS_OBJECTDESC);
  172.     if (SUCCEEDED(m_pLoader->GetObject(&ObjectDescript, IID_IDirectMusicSegment, (void**)&m_pSegment)))
  173.     {
  174.  
  175.         return TRUE;
  176.     }
  177.  
  178.     return FALSE;
  179. }
  180.  
  181.  
  182.  
  183.  
  184. //-----------------------------------------------------------------------------
  185. // Name: 
  186. // Desc: Load the dls set that the band needs, but just leave it in the cache.
  187. //          Then, it will be referenced and loaded by the bands in the styles and 
  188. //       segments.
  189. //-----------------------------------------------------------------------------
  190. HRESULT BoidMusic::LoadDLS()
  191. {
  192.     DMUS_OBJECTDESC dmod;
  193.     dmod.dwSize      = sizeof(DMUS_OBJECTDESC);
  194.     dmod.guidClass   = CLSID_DirectMusicCollection;
  195.     dmod.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME ;
  196.     wcscpy(dmod.wszFileName, L"Boids.dls");
  197.  
  198.     IDirectMusicCollection* pCollect = NULL;
  199.     if( FAILED( m_pLoader->GetObject( &dmod, IID_IDirectMusicCollection, 
  200.                                       (VOID**)&pCollect ) ) )
  201.         return E_FAIL;
  202.  
  203.     pCollect->Release();
  204.     return S_OK;
  205. }
  206.  
  207.  
  208.  
  209.  
  210. //-----------------------------------------------------------------------------
  211. // Name: 
  212. // Desc: Load the Boids chord map.
  213. //-----------------------------------------------------------------------------
  214. BOOL BoidMusic::LoadChordMap()
  215. {
  216.     if (m_pChordMap) m_pChordMap->Release();
  217.  
  218.     DMUS_OBJECTDESC ObjectDescript;
  219.     ObjectDescript.guidClass = CLSID_DirectMusicChordMap;
  220.     wcscpy(ObjectDescript.wszFileName, L"Boids.cdm");
  221.     ObjectDescript.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME;
  222.     ObjectDescript.dwSize = sizeof(DMUS_OBJECTDESC);
  223.     if (SUCCEEDED(m_pLoader->GetObject(&ObjectDescript, IID_IDirectMusicChordMap, (void**)&m_pChordMap)))
  224.     {
  225.         return TRUE;
  226.     }
  227.  
  228.     return FALSE;
  229. }
  230.  
  231.  
  232.  
  233.  
  234. //-----------------------------------------------------------------------------
  235. // Name: 
  236. // Desc: Load a template and place it in the m_pTemplateSegments[] array.
  237. //-----------------------------------------------------------------------------
  238. BOOL BoidMusic::LoadTemplate(DWORD dwIndex, WCHAR * pwzName)
  239. {     
  240.     if (m_pTemplateSegments[dwIndex]) m_pTemplateSegments[dwIndex]->Release();
  241.  
  242.     HRESULT hr;
  243.     DMUS_OBJECTDESC ObjectDescript;
  244.  
  245.     ObjectDescript.guidClass = CLSID_DirectMusicSegment;
  246.     wcscpy(ObjectDescript.wszFileName, pwzName);
  247.     ObjectDescript.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME;
  248.     ObjectDescript.dwSize = sizeof(DMUS_OBJECTDESC);
  249.     if (SUCCEEDED( hr = m_pLoader->GetObject(&ObjectDescript, IID_IDirectMusicSegment, (void**)&m_pTemplateSegments[dwIndex])))
  250.     {
  251.         return TRUE;
  252.     }
  253.  
  254.     return FALSE;
  255. }
  256.  
  257.  
  258.  
  259.  
  260. //-----------------------------------------------------------------------------
  261. // Name: 
  262. // Desc: Use the composer to compose a style segment from a previously loaded
  263. //         template segment, the boids chord map and style. Place the
  264. //         segment in the m_pPrimarySegments[] array.
  265. //-----------------------------------------------------------------------------
  266. void BoidMusic::ComposeSegment(DWORD dwIndex)
  267. {     
  268.  
  269.     if (m_pComposer && m_pStyle && m_pChordMap && m_pTemplateSegments[dwIndex])
  270.     {
  271.         if (m_pPrimarySegments[dwIndex])
  272.         {
  273.             m_pPrimarySegments[dwIndex]->Release();
  274.             m_pPrimarySegments[dwIndex] = NULL;
  275.         }
  276.         m_pComposer->ComposeSegmentFromTemplate(
  277.             m_pStyle,
  278.             m_pTemplateSegments[dwIndex],
  279.             1,
  280.             m_pChordMap,
  281.             &m_pPrimarySegments[dwIndex]);
  282.         if (m_pPrimarySegments[dwIndex])
  283.         {
  284.             m_pPrimarySegments[dwIndex]->SetRepeats(100);
  285.  
  286.         }
  287.     }
  288. }
  289.  
  290.  
  291.  
  292.  
  293. //-----------------------------------------------------------------------------
  294. // Name: 
  295. // Desc: Pull the named motif segment from the boids style.
  296. //         Note that we currently use the OLE BSTR string approach.
  297. //         This will probably change in the next beta.
  298. //-----------------------------------------------------------------------------
  299. BOOL BoidMusic::GetMotif(DWORD dwIndex, WCHAR * pszName)
  300. { 
  301.     if (m_pStyle)
  302.     {    
  303.         if (SUCCEEDED(m_pStyle->GetMotif(pszName, &m_pMotifSegments[dwIndex])))
  304.         {
  305.             return TRUE;
  306.         }
  307.     }
  308.  
  309.     return FALSE;
  310. }
  311.  
  312.  
  313.  
  314.  
  315. //-----------------------------------------------------------------------------
  316. // Name: 
  317. // Desc: Check for a notify event. Since we are only waiting for
  318. //         notification of beats, we increment out beat counter. The beat counter
  319. //       is used by the boids app to manage the number of motifs allowed at any
  320. //       point in time. This keeps things from getting too overcrowded.
  321. //       Alternatively, the notifications could be used to synchronize graphic
  322. //       events.
  323. //-----------------------------------------------------------------------------
  324. void BoidMusic::HandleNotifies()
  325. {
  326.     DMUS_NOTIFICATION_PMSG* pMsg;
  327.     if( m_hNotify && m_pPerformance)
  328.     {
  329.         WaitForSingleObject(m_hNotify, 2);
  330.         while( S_OK == m_pPerformance->GetNotificationPMsg(&pMsg))
  331.         {
  332.             m_pPerformance->FreePMsg((DMUS_PMSG*)pMsg);
  333.             m_dwBeatsSinceLastMotif++;
  334.         }
  335.     }
  336. }
  337.  
  338.  
  339.  
  340.  
  341. //-----------------------------------------------------------------------------
  342. // Name: 
  343. // Desc: This is called by the app, once it gets its main window up.
  344. //       Activate the synth and start the music playing.
  345. //-----------------------------------------------------------------------------
  346. void BoidMusic::StartMusic()
  347. {
  348.     if (m_pDMusic)
  349.     {
  350.         m_pDMusic->Activate(TRUE);
  351.     }
  352.     if (m_pPrimarySegments[0])
  353.     {
  354.         m_pPerformance->PlaySegment( 
  355.             m_pPrimarySegments[0], 0, 0, NULL);
  356.         m_dwIndex = 0;
  357.     }    
  358. }
  359.  
  360.  
  361.  
  362.  
  363. //-----------------------------------------------------------------------------
  364. // Name: 
  365. // Desc: This is called from the graphics loop. As we get closer to the center
  366. //       of the flock of birds, increase the number of echoes for the echo tool,
  367. //       and also increase the duration scalings (makes the note durations
  368. //       longer.)
  369. //-----------------------------------------------------------------------------
  370. void BoidMusic::SetDistance(double fDistance)
  371. {
  372.     double fTemp = fDistance - 10.0;
  373.     fTemp = 70.0 - fTemp;
  374.     if (fTemp < 0.0) fTemp = 0.0;
  375.     m_Tool.m_dwEcho = (DWORD)(fTemp / 15.0);
  376.     m_Tool.m_dwStartRatio = (DWORD)(75 + fTemp);
  377.     m_Tool.m_dwRatio = m_Tool.m_dwStartRatio;
  378. }
  379.  
  380.  
  381.  
  382.  
  383. //-----------------------------------------------------------------------------
  384. // Name: 
  385. // Desc: Whenever the flock is about to hit a sphere, this is called. It
  386. //       chooses the next segment to go to and plays the planet motif leading
  387. //       into the next segment. Notice how it takes the start time of the 
  388. //       planet motif, adds one, and uses that to start the segment, but on a
  389. //       beat boundary. This tricks the segment to start one beat later than
  390. //       the motif, creating a smooth musical transition.
  391. //-----------------------------------------------------------------------------
  392. void BoidMusic::Transition()
  393. {
  394.     if (!m_fCollapsed && (m_dwBeatsSinceLastMotif > 2))
  395.     {
  396.         static DWORD dwChoice[8] = { 0, 2, 1, 3, 0, 4, 1, 5 };
  397.         m_dwIndex++;
  398.         if (m_dwIndex > 8) m_dwIndex = 2;
  399.         if (m_dwIndex > 0) 
  400.         {
  401.             if (m_pMotifSegments[0] && m_pPrimarySegments[dwChoice[m_dwIndex-1]]) 
  402.             {
  403.                 IDirectMusicSegmentState *pState = NULL;
  404.                 m_pPerformance->PlaySegment(
  405.                     m_pMotifSegments[0], (DMUS_SEGF_SECONDARY | DMUS_SEGF_BEAT ), 0, &pState);
  406.                 if (pState)
  407.                 {
  408.                     MUSIC_TIME mtTime;
  409.                     pState->GetStartTime(&mtTime);
  410.                     pState->Release();
  411.                     mtTime++;
  412.                     m_pPerformance->PlaySegment( 
  413.                             m_pPrimarySegments[dwChoice[m_dwIndex-1]], DMUS_SEGF_BEAT , mtTime, NULL);
  414.                 }
  415.             }
  416.         }
  417.     }
  418. }
  419.  
  420.  
  421.  
  422.  
  423. //-----------------------------------------------------------------------------
  424. // Name: 
  425. // Desc: When the migration force is turned off, the birds start to migrate
  426. //       away. So, this starts the migration theme. Note that it plays once,
  427. //       and then one of the regular segments is queued to pick up after it.
  428. //-----------------------------------------------------------------------------
  429. void BoidMusic::Migrate()
  430. {
  431.     if (m_pSegment) 
  432.     {
  433.         m_pPerformance->PlaySegment( 
  434.                     m_pSegment, DMUS_SEGF_BEAT , 0, NULL);
  435.     }
  436.     if (m_pPrimarySegments[2])
  437.     {
  438.         m_pPerformance->PlaySegment( 
  439.                     m_pPrimarySegments[2], DMUS_SEGF_QUEUE , 0, NULL);
  440.     }
  441. }
  442.  
  443.  
  444.  
  445.  
  446. //-----------------------------------------------------------------------------
  447. // Name: 
  448. // Desc: When the 's' key or space bar is hit, the birds collapse together. Set
  449. //       the collapsed flag indicating the new state. Trigger two motifs to
  450. //       play. The first simply plays the collapse motif. The second plays a 
  451. //       cycling motif until the user lifts up, calling the Expand() function. 
  452. //-----------------------------------------------------------------------------
  453. void BoidMusic::Collapse()
  454. {
  455.     m_fCollapsed = TRUE;
  456.     if (m_dwBeatsSinceLastMotif)
  457.     {
  458.         if (m_pMotifSegments[5])
  459.         {
  460.             m_pPerformance->PlaySegment(
  461.                 m_pMotifSegments[5], (DMUS_SEGF_SECONDARY | DMUS_SEGF_GRID), 0, NULL);
  462.         }
  463.         if (m_pMotifSegments[3])
  464.         {
  465.             m_pMotifSegments[3]->SetRepeats(20);
  466.             m_pPerformance->PlaySegment(
  467.                 m_pMotifSegments[3], (DMUS_SEGF_SECONDARY | DMUS_SEGF_MEASURE), 0, NULL);
  468.         }
  469.         m_dwBeatsSinceLastMotif = 0;
  470.     }
  471. }
  472.  
  473.  
  474.  
  475.  
  476. //-----------------------------------------------------------------------------
  477. // Name: 
  478. // Desc: When the user releases the 's' key or space bar, the birds can move
  479. //       apart again. Notice that the repeating motif is turned off by calling
  480. //       stop on it.
  481. //-----------------------------------------------------------------------------
  482. void BoidMusic::Expand()
  483. {
  484.     m_fCollapsed = FALSE;
  485.     if (m_dwBeatsSinceLastMotif)
  486.     {
  487.         if (m_pMotifSegments[4])
  488.         {
  489.             m_pPerformance->PlaySegment(
  490.                 m_pMotifSegments[4], (DMUS_SEGF_SECONDARY | DMUS_SEGF_GRID), 0, NULL);
  491.         }
  492.         m_dwBeatsSinceLastMotif = 0;
  493.     }
  494.     if (m_pMotifSegments[3])
  495.     {
  496.         m_pPerformance->Stop(m_pMotifSegments[3], NULL, 0, 0);
  497.     }
  498. }
  499.  
  500.  
  501.  
  502.  
  503. //-----------------------------------------------------------------------------
  504. // Name: 
  505. // Desc: Close down all the music stuff.
  506. //-----------------------------------------------------------------------------
  507. void BoidMusic::EndMusic()
  508. {
  509.     m_Tool.m_pPerformance = NULL;
  510.     if (m_pPerformance)
  511.     {
  512.         m_pPerformance->Stop( NULL, NULL, 0, 0);
  513.     }
  514.     if (m_pSegment)
  515.     {
  516.         m_pSegment->Release();
  517.         m_pSegment = NULL;
  518.     }
  519.     if (m_pBand)
  520.     {
  521.         if(m_pPerformance)
  522.         {
  523.             m_pBand->Unload(m_pPerformance);
  524.         }
  525.         m_pBand->Release();
  526.         m_pBand = NULL;
  527.     }
  528.     if (m_pPort)
  529.     {
  530.         m_pPort->Release();
  531.         m_pPort = NULL;
  532.     }
  533.     if (m_pDMusic)
  534.     {
  535.         m_pDMusic->Release();
  536.         m_pDMusic = NULL;
  537.     }
  538.     if (m_pGraph)
  539.     {
  540.         m_pGraph->Release();
  541.         m_pGraph = NULL;
  542.     }
  543.     long x;
  544.     for (x = 0; x< 6; x++)
  545.     {
  546.         if (m_pTemplateSegments[x])
  547.         {
  548.             m_pTemplateSegments[x]->Release();
  549.             m_pTemplateSegments[x] = NULL;
  550.         }
  551.         if (m_pPrimarySegments[x])
  552.         {
  553.             m_pPrimarySegments[x]->Release();
  554.             m_pPrimarySegments[x] = NULL;
  555.         }
  556.         if (m_pMotifSegments[x])
  557.         {
  558.             m_pMotifSegments[x]->Release();
  559.             m_pMotifSegments[x] = NULL;
  560.         }
  561.     }
  562.     if (m_pStyle)
  563.     {
  564.         m_pStyle->Release();
  565.         m_pStyle = NULL;
  566.     }
  567.     if (m_pChordMap)
  568.     {
  569.         m_pChordMap->Release();
  570.         m_pChordMap = NULL;
  571.     }
  572.     if (m_pTransitionSegment)
  573.     {
  574.         m_pTransitionSegment->Release();
  575.         m_pTransitionSegment = NULL;
  576.     }
  577.     if (m_pComposer)
  578.     {
  579.         m_pComposer->Release();
  580.         m_pComposer = NULL;
  581.     }
  582.     if (m_pLoader)
  583.     {
  584.         m_pLoader->Release();
  585.         m_pLoader = NULL;
  586.     }
  587.     if (m_pPerformance)
  588.     {
  589.         m_pPerformance->Stop( NULL, NULL, 0, 0);
  590.         m_pPerformance->CloseDown();
  591.         m_pPerformance->Release();
  592.         m_pPerformance = NULL;
  593.     }
  594.     CoUninitialize();
  595. }
  596.  
  597. static char szDirectMusicMedia[] = "Media";
  598.  
  599.  
  600.  
  601.  
  602. //-----------------------------------------------------------------------------
  603. // Name: 
  604. // Desc:
  605. //-----------------------------------------------------------------------------
  606. BOOL BoidMusic::GetSearchPath(WCHAR wszPath[MAX_PATH])
  607. {
  608.     const TCHAR* szDir = DXUtil_GetDXSDKMediaPath();
  609.     mbstowcs(wszPath, szDir, MAX_PATH);
  610.  
  611.     return TRUE;
  612. }
  613.  
  614.  
  615.  
  616.  
  617. // Tool implementation follows. Pretty much all the meat is in the
  618. // ProcessEvent() method.
  619.  
  620. //-----------------------------------------------------------------------------
  621. // Name: 
  622. // Desc:
  623. //-----------------------------------------------------------------------------
  624. CTool::CTool()
  625. {
  626.     m_dwRatio = 100;
  627.     m_dwStartRatio = 100;
  628.     m_dwEcho = 1;
  629.     m_cRef = 0;
  630.     m_dwDelay = 96;
  631.     m_pPerformance = NULL;
  632. }
  633.  
  634.  
  635.  
  636.  
  637. //-----------------------------------------------------------------------------
  638. // Name: 
  639. // Desc:
  640. //-----------------------------------------------------------------------------
  641. CTool::~CTool()
  642. {
  643. }
  644.  
  645.  
  646. //-----------------------------------------------------------------------------
  647. // Name: 
  648. // Desc:
  649. //-----------------------------------------------------------------------------
  650. STDMETHODIMP CTool::QueryInterface( const IID &iid, void **ppv)       
  651. {
  652.     if (iid == IID_IDirectMusicTool)
  653.     {
  654.         *ppv = static_cast<IDirectMusicTool*>(this);
  655.     } else
  656.     {
  657.         *ppv = NULL;
  658.         return E_NOINTERFACE;
  659.     }
  660.  
  661.     reinterpret_cast<IUnknown*>(this)->AddRef();
  662.     return S_OK;
  663. }
  664.  
  665.  
  666.  
  667.  
  668. //-----------------------------------------------------------------------------
  669. // Name: 
  670. // Desc:
  671. //-----------------------------------------------------------------------------
  672. STDMETHODIMP_(ULONG) CTool::AddRef()
  673. {
  674.     return InterlockedIncrement(&m_cRef);
  675. }
  676.  
  677.  
  678.  
  679.  
  680. //-----------------------------------------------------------------------------
  681. // Name: 
  682. // Desc:
  683. //-----------------------------------------------------------------------------
  684. STDMETHODIMP_(ULONG) CTool::Release()
  685. {
  686.     if (!InterlockedDecrement(&m_cRef))
  687.     {
  688.         return 0;
  689.     }
  690.  
  691.     return m_cRef;
  692. }
  693.  
  694.  
  695.  
  696.  
  697. //-----------------------------------------------------------------------------
  698. // Name: 
  699. // Desc:
  700. //-----------------------------------------------------------------------------
  701. HRESULT STDMETHODCALLTYPE CTool::ProcessPMsg( IDirectMusicPerformance* pPerf, 
  702.                                               DMUS_PMSG* pMsg ) 
  703. {
  704.     HRESULT hr = S_OK;
  705.     if (pMsg->pGraph)
  706.     {
  707.         if (SUCCEEDED(pMsg->pGraph->StampPMsg(pMsg)))
  708.         {
  709.             hr = DMUS_S_REQUEUE;
  710.         }
  711.     }
  712.     switch( pMsg->dwType )
  713.     {
  714.     case DMUS_PMSGT_NOTE:
  715.         {
  716.             /*    If we receive a note, first adjust the duration
  717.                 by m_dwRatio.
  718.             */
  719.             DMUS_NOTE_PMSG *pNote = (DMUS_NOTE_PMSG *) pMsg;
  720.             if (m_dwRatio < 1) m_dwRatio = 1;
  721.             if (m_dwRatio > 400) m_dwRatio = 400;
  722.             pNote->mtDuration = MulDiv(pNote->mtDuration,m_dwRatio,100);
  723.             /*    Then, if it is on the PChannel of the melody,
  724.                 set it to echo the number of times established
  725.                 by m_dwEcho. Note that the echo algorithm is 
  726.                 quite simple but powerful: copy the event and play
  727.                 it on an adjacent PChannel. By playing it on a different
  728.                 PChannel, we take care of overlapping notes and
  729.                 we can have it panned differently.
  730.             */
  731.             if (m_dwEcho && (pNote->dwPChannel == 7))
  732.             {
  733.                 if (pPerf)
  734.                 {
  735.                     DWORD dwX;
  736.                     if (m_dwEcho > 3) m_dwEcho = 3;
  737.                     for (dwX = 0; dwX < m_dwEcho; dwX++)
  738.                     {
  739.                         DMUS_NOTE_PMSG * pEcho;
  740.                         if (SUCCEEDED(pPerf->AllocPMsg( sizeof(DMUS_NOTE_PMSG),
  741.                             (DMUS_PMSG**) &pEcho)))
  742.                         {
  743.                             static DWORD dwChannels[3] = { 6, 15, 0 };
  744.                             memcpy( pEcho, pNote, sizeof(DMUS_NOTE_PMSG) );
  745.                             pEcho->dwPChannel = dwChannels[dwX];
  746.                             pEcho->mtTime = pNote->mtTime + (m_dwDelay * (dwX + 1));
  747.                             pEcho->dwFlags = DMUS_PMSGF_MUSICTIME;
  748.                             if (pEcho->pGraph) pEcho->pGraph->AddRef();
  749.                             if (pEcho->pTool) pEcho->pTool->AddRef();
  750.                             pPerf->SendPMsg( (DMUS_PMSG*)pEcho) ;
  751.                         }
  752.                     }
  753.                 }
  754.             }
  755.         }
  756.         break;
  757.     case DMUS_PMSGT_CURVE:
  758.         break;
  759.     case DMUS_PMSGT_SYSEX:
  760.         break;
  761.     case DMUS_PMSGT_MIDI:
  762.         /*    Also, if we receive program changes, volumes, or pans on the 
  763.             PChannel of the melody, set up the echos to use the same patch,
  764.             a diminishing volume, and assign the pans appropriately.
  765.             This way, if a different band with different setting is loaded,
  766.             the echoed parts will all get reset appropriately.
  767.         */
  768.         {
  769.             DMUS_MIDI_PMSG *pMidi = (DMUS_MIDI_PMSG *) pMsg;
  770.             if (pMidi->dwPChannel == 7)
  771.             {
  772.                 DWORD dwX;
  773.                 for (dwX = 0;dwX < 3; dwX++)
  774.                 {
  775.                     DMUS_MIDI_PMSG * pEcho;
  776.                     if (SUCCEEDED(m_pPerformance->AllocPMsg( sizeof(DMUS_MIDI_PMSG),
  777.                         (DMUS_PMSG**) &pEcho)))
  778.                     {
  779.                         static DWORD dwChannels[3] = { 6, 15, 0 };
  780.                         static BYTE bPans[3] = { 80,0,120 };
  781.                         memcpy( pEcho, pMidi, sizeof(DMUS_MIDI_PMSG) );
  782.                         pEcho->dwPChannel = dwChannels[dwX];
  783.                         pEcho->mtTime = pMsg->mtTime + 20;
  784.                         pEcho->dwFlags = DMUS_PMSGF_MUSICTIME;
  785.                         if (pMidi->bStatus == 0xB0)
  786.                         {
  787.                             if (pMidi->bByte1 == 10)
  788.                             {
  789.                                 pEcho->bByte2 = bPans[dwX];
  790.                             }
  791.                             else if (pMidi->bByte1 == 7)
  792.                             {
  793.                                 pEcho->bByte2 = pMidi->bByte2 - (((BYTE)dwX+1) * 20);
  794.                                 if (pEcho->bByte2 > 127) pEcho->bByte2 = 10;
  795.                             }
  796.                         }
  797.                         if (pEcho->pGraph) pEcho->pGraph->AddRef();
  798.                         if (pEcho->pTool) pEcho->pTool->AddRef();
  799.                         m_pPerformance->SendPMsg( (DMUS_PMSG*)pEcho) ;
  800.                     }
  801.                 }
  802.             }
  803.         }
  804.         break;
  805.     case DMUS_PMSGT_PATCH:
  806.         break;
  807.     default:
  808.         break;
  809.     }
  810.  
  811.     return hr;
  812. }
  813.  
  814.  
  815.  
  816.  
  817. //-----------------------------------------------------------------------------
  818. // Name: 
  819. // Desc:
  820. //-----------------------------------------------------------------------------
  821. HRESULT STDMETHODCALLTYPE CTool::Flush( IDirectMusicPerformance* pPerf, 
  822.                                         DMUS_PMSG* pMsg, REFERENCE_TIME rt )
  823. {
  824.     return S_OK;
  825. }
  826.  
  827.  
  828.  
  829.  
  830. //-----------------------------------------------------------------------------
  831. // Name: 
  832. // Desc:
  833. //-----------------------------------------------------------------------------
  834. HRESULT STDMETHODCALLTYPE CTool::Init( IDirectMusicGraph* pGraph )
  835. {
  836.     return E_NOTIMPL;
  837. }
  838.  
  839.  
  840.  
  841.  
  842. //-----------------------------------------------------------------------------
  843. // Name: 
  844. // Desc:
  845. //-----------------------------------------------------------------------------
  846. HRESULT STDMETHODCALLTYPE  CTool::GetMsgDeliveryType( DWORD* pdwDeliveryType ) 
  847. {
  848.     return E_NOTIMPL;
  849. }
  850.  
  851.  
  852.  
  853.  
  854. //-----------------------------------------------------------------------------
  855. // Name: 
  856. // Desc:
  857. //-----------------------------------------------------------------------------
  858. HRESULT STDMETHODCALLTYPE  CTool::GetMediaTypeArraySize( DWORD* pdwNumElements ) 
  859. {
  860.     return E_NOTIMPL;
  861. }
  862.  
  863.  
  864.  
  865.  
  866. //-----------------------------------------------------------------------------
  867. // Name: 
  868. // Desc:
  869. //-----------------------------------------------------------------------------
  870. HRESULT STDMETHODCALLTYPE  CTool::GetMediaTypes( DWORD** padwMediaTypes, 
  871.                                                  DWORD dwNumElements ) 
  872. {
  873.     return E_NOTIMPL;
  874. }
  875.  
  876.  
  877.  
  878.  
  879. //-----------------------------------------------------------------------------
  880. // Name: 
  881. // Desc:
  882. //-----------------------------------------------------------------------------
  883. HRESULT BoidMusic::LoadMusic( HWND hwnd )
  884. {
  885.     HRESULT hr;
  886.        
  887.     CoInitialize(NULL);
  888.     hr = CoCreateInstance( CLSID_DirectMusicLoader, NULL, CLSCTX_INPROC, 
  889.                            IID_IDirectMusicLoader, (VOID**)&m_pLoader );
  890.     if( FAILED(hr) ) 
  891.     {
  892.         OutputDebugString("Couldn't create CLSID_DirectMusicLoader\n");
  893.         return hr;
  894.     }
  895.  
  896.     WCHAR dir[MAX_PATH];
  897.     
  898.     m_pLoader->EnableCache(GUID_DirectMusicAllTypes, TRUE);
  899.  
  900.     hr = E_FAIL;
  901.     if (BoidMusic::GetSearchPath(dir))
  902.     {
  903.         hr = m_pLoader->SetSearchDirectory(GUID_DirectMusicAllTypes, dir, FALSE);
  904.     }
  905.     if (FAILED(hr))
  906.     {
  907.         hr = m_pLoader->SetSearchDirectory(GUID_DirectMusicAllTypes, L".", FALSE);
  908.     }
  909.     if (FAILED(hr))
  910.     {
  911.         OutputDebugString("Couldn't set DirectMusic search path");
  912.         return hr;
  913.     }
  914.  
  915.     hr = ::CoCreateInstance( CLSID_DirectMusicComposer, NULL, CLSCTX_INPROC, 
  916.                              IID_IDirectMusicComposer, (VOID**)&m_pComposer);
  917.     if( FAILED(hr) ) 
  918.     {
  919.         OutputDebugString("Couldn't create CLSID_DirectMusicComposer\n");
  920.         return hr;
  921.     }
  922.  
  923.     BOOL bResourcesOk = TRUE;
  924.  
  925.     bResourcesOk = bResourcesOk && SUCCEEDED( LoadDLS() );
  926.     bResourcesOk = bResourcesOk && LoadStyle();
  927.     bResourcesOk = bResourcesOk && LoadChordMap();
  928.     bResourcesOk = bResourcesOk && LoadTemplate(0,L"BoidsAA.tpl");
  929.     bResourcesOk = bResourcesOk && LoadTemplate(1,L"BoidB1.tpl");
  930.     bResourcesOk = bResourcesOk && LoadTemplate(2,L"BoidsC1.tpl");
  931.     bResourcesOk = bResourcesOk && LoadTemplate(3,L"BoidsCA.tpl");
  932.     bResourcesOk = bResourcesOk && LoadTemplate(4,L"BoidsCB.tpl");
  933.  
  934.     bResourcesOk = bResourcesOk && LoadTemplate(5,L"BoidsCC.tpl");
  935.     
  936.     ComposeSegment(0);
  937.     ComposeSegment(1);
  938.     ComposeSegment(2);
  939.     ComposeSegment(3);
  940.     ComposeSegment(4);
  941.     ComposeSegment(5);
  942.  
  943.     bResourcesOk = bResourcesOk && LoadSegment();
  944.     bResourcesOk = bResourcesOk && GetMotif(0, L"planet");
  945.     bResourcesOk = bResourcesOk && GetMotif(1, L"D motif");
  946.     bResourcesOk = bResourcesOk && GetMotif(2, L"motif RL med");
  947.     bResourcesOk = bResourcesOk && GetMotif(3, L"Cycle");
  948.     bResourcesOk = bResourcesOk && GetMotif(4, L"Expand");
  949.     bResourcesOk = bResourcesOk && GetMotif(5, L"Collapse");
  950.  
  951.     if (!bResourcesOk)
  952.     {
  953.         OutputDebugString("Couldn't load DirectMusic resources\n");
  954.         return E_FAIL;
  955.     }
  956.  
  957.     hr = CoCreateInstance( CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER,
  958.                            IID_IDirectMusic, (VOID**)&m_pDMusic);
  959.     if (FAILED(hr))
  960.     {
  961.         OutputDebugString("Couldn't create CLSID_DirectMusic\n");
  962.         return hr;
  963.     }
  964.  
  965.     hr = m_pDMusic->SetDirectSound(NULL, hwnd);
  966.     if (FAILED(hr))
  967.     {
  968.         OutputDebugString("Could't SetDirectSound on IDirectMusic\n");
  969.         return hr;
  970.     }
  971.  
  972.     DMUS_PORTPARAMS dmos;
  973.     DMUS_PORTCAPS dmpc;
  974.     GUID guidSynthGUID;
  975.     
  976.     hr = m_pDMusic->GetDefaultPort(&guidSynthGUID);
  977.     if (FAILED(hr))
  978.     {
  979.         OutputDebugString("Could't GetDefaultPort on IDirectMusic\n");
  980.         return hr;
  981.     }
  982.  
  983.     ZeroMemory(&dmos, sizeof(dmos));
  984.     dmos.dwSize = sizeof(DMUS_PORTPARAMS);
  985.     dmos.dwChannelGroups = 1;
  986.     dmos.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
  987.  
  988.     hr = m_pDMusic->CreatePort( guidSynthGUID, &dmos, &m_pPort, NULL );
  989.     if (FAILED(hr))
  990.     {
  991.         OutputDebugString("Couldn't CreatePort on IDirectMusic\n");
  992.         return hr;
  993.     }
  994.  
  995.     ZeroMemory(&dmpc, sizeof(dmpc));
  996.     dmpc.dwSize = sizeof(DMUS_PORTCAPS);
  997.  
  998.     hr = m_pPort->GetCaps(&dmpc);
  999.     if (FAILED(hr))
  1000.     {
  1001.         OutputDebugString("Couldn't GetCaps on IDirectMusicPort\n");
  1002.         return hr;
  1003.     }
  1004.  
  1005.     if ((dmpc.dwClass != DMUS_PC_OUTPUTCLASS) || !(dmpc.dwFlags & DMUS_PC_DLS))
  1006.     {
  1007.         m_pPort->Release();
  1008.         m_pPort = NULL;
  1009.     }
  1010.  
  1011.     if (!m_pPort)
  1012.     {
  1013.         hr = E_FAIL;
  1014.  
  1015.         for (DWORD index = 0; ; index++)
  1016.         {
  1017.             ZeroMemory(&dmpc, sizeof(dmpc));
  1018.             dmpc.dwSize = sizeof(DMUS_PORTCAPS);
  1019.  
  1020.             hr = m_pDMusic->EnumPort(index, &dmpc);
  1021.             if(SUCCEEDED(hr) && hr != S_FALSE)
  1022.             {
  1023.                 if ( (dmpc.dwClass == DMUS_PC_OUTPUTCLASS) && 
  1024.                      (dmpc.dwFlags & DMUS_PC_DLS) )
  1025.                 {
  1026.                     CopyMemory(&guidSynthGUID, &dmpc.guidPort, sizeof(GUID));
  1027.                     
  1028.                     ZeroMemory(&dmos, sizeof(dmos));
  1029.                     dmos.dwSize = sizeof(DMUS_PORTPARAMS);
  1030.                     dmos.dwChannelGroups = 1;
  1031.                     dmos.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
  1032.  
  1033.                     hr = m_pDMusic->CreatePort( guidSynthGUID, &dmos,
  1034.                                                 &m_pPort, NULL );
  1035.                     break;
  1036.                 }
  1037.             }
  1038.             else
  1039.             {
  1040.                 break;
  1041.             }
  1042.         }
  1043.     }
  1044.  
  1045.     if (FAILED(hr))
  1046.     {
  1047.         OutputDebugString("Couldn't find or CreatePort software synthesizer\n");
  1048.         return hr;
  1049.     }
  1050.  
  1051.     hr = CoCreateInstance( CLSID_DirectMusicPerformance, NULL, CLSCTX_ALL, 
  1052.                            IID_IDirectMusicPerformance, (VOID**)&m_pPerformance );
  1053.     if (FAILED(hr))
  1054.     {
  1055.         OutputDebugString("Couldn't create CLSID_DirectMusicPerformance\n");
  1056.         return hr;
  1057.     }
  1058.  
  1059.     hr = m_pPerformance->Init(&m_pDMusic, NULL, NULL);
  1060.     if (FAILED(hr))
  1061.     {
  1062.         OutputDebugString("Couldn't init CLSID_DirectMusicPerformance\n");
  1063.         return hr;
  1064.     }
  1065.  
  1066.     m_pPerformance->AddPort(m_pPort );
  1067.     m_pPerformance->AssignPChannelBlock(0, m_pPort, 1);
  1068.     m_hNotify = CreateEvent( NULL, FALSE, FALSE, NULL );
  1069.     if( m_hNotify )
  1070.     {
  1071.         GUID guid;
  1072.         m_pPerformance->SetNotificationHandle( m_hNotify, 0 );
  1073.         guid = GUID_NOTIFICATION_MEASUREANDBEAT;
  1074.         m_pPerformance->AddNotificationType( guid );
  1075.     }
  1076.     m_Tool.m_pPerformance = m_pPerformance;
  1077.     if (m_pBand)
  1078.     {
  1079.         m_pBand->Download(m_pPerformance);
  1080.     }
  1081.  
  1082.     hr = ::CoCreateInstance( CLSID_DirectMusicGraph, NULL, CLSCTX_INPROC, 
  1083.                              IID_IDirectMusicGraph, (VOID**)&m_pGraph );
  1084.     if (FAILED(hr))
  1085.     {
  1086.         OutputDebugString("Couldn't create CLSID_DirectMusicGraph\n");
  1087.         return hr;
  1088.     }
  1089.  
  1090.     m_pPerformance->SetGraph(m_pGraph);
  1091.     IDirectMusicTool *pTool;
  1092.     hr = m_Tool.QueryInterface(IID_IDirectMusicTool, (void**)&pTool);
  1093.     if (FAILED(hr))
  1094.     {
  1095.         OutputDebugString("Couldn't InsertTool on graph\n");
  1096.         return hr;
  1097.     }
  1098.  
  1099.     m_pGraph->InsertTool( pTool, 0, NULL, 0);
  1100.  
  1101.     return S_OK;;
  1102. }
  1103.  
  1104.  
  1105. //-----------------------------------------------------------------------------
  1106. // Name: 
  1107. // Desc:
  1108. //-----------------------------------------------------------------------------
  1109. void BoidMusic::Activate( BOOL bActive )
  1110. {
  1111.     if (m_pDMusic)
  1112.     {
  1113.         m_pDMusic->Activate(bActive);
  1114.     }
  1115. }
  1116.